package comone.comfive;

public class Demo {
    /*优化：对程序优化
    * 面向对象三大核心:封装，继承，多态
    * 一：封装：----安全
    *       广义：对业务的封装。
    *       狭义：给对象属性私有化，提供get和set方法以便于访问。
    *     1:访问修饰符：
                private	    可以	不可以	不可以	不可以
                默认修饰符	可以	可以	（子类父子不同包）不可以	不可以
                protected	可以	可以	可以	不可以
                public	    可以	可以	可以	可以

          2:static:静态关键字
             1):能干什么：修饰成员属性，成员方法，代码块
             2):为什么用：为了不需要实力对象，就想访问类中的属性和方法。
             3):怎么用：static

           static修饰变量/类变量：
                  全局共享 就只有一份拷贝。
                  类内部，可在任何方法内直接访问静态变量。
                  其他类中，可以直接通过类名访问。
           static修饰方法/静态方法：
                  可直接通过类名访问。
                  可以调用静态方法和属性，不能调用非静态的方法和属性。
           static修饰代码块：
                  只加载一次，优先加载，多个按单块顺序加载

      二：继承：代码冗余----思想性的
                广义：使用继承设计程序业务模块。
                狭义：在练习中继承的实现过程，了解继承的具体实现方式。

            1):哪些能继承：
                1：非私有的属性和行为

            2):哪些不能继承：
                1：私有的属性和行为。
                2：静态方法不参与继承。
                3：构造方法不能被继承，但是可以在子类中被调用
                        注意：只能在子类中的构造方法的第一句使用supper关键字调用,
                           子类会默认自动调用父类的无参构造,除非子类显示调用父类的有参构造。

            3):继承的特性：单根性，一个子类只能有一个直接的父类，具备延续性。
                        注意：任何类都有一个基类Object

            4):继承怎么实现：使用extends关键字完成继承。

            5):继承后如何访问父类的属性和行为：this supper关键字。
                         this:子类对象，supper：父类对象

            6): 何时使用：符合is-a关系的设计使用继承

            7):继承应用场景：
                1>：两个或者两个以上的类，不相同的属性和方法。
                  抽离出来封装成一个父类，由子类进行继承。
                2>：为程序统一设置相同行为方法。
                3>：当前对象的行为不满足使用，可以直接继承其他有相似行为的类，
                    拓展本类的行为。

            8):重写：当父类的行为不满足，子类的需要时，子类会选择重写这个行为。
                 注意：子类重写父类的行为，当进行到用时，不会再调用父类的行为了。

                特征-->前提：发生在两个或以上的类：
                    1：方法名相同。
                    2：参数列表相同。
                    3：返回值类型相同或者是其子类。
                    4：父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法。
                    5：子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super).
                    6：父类的私有方法不能被子类覆盖。
                    7：不能抛出比父类方法更多的异常。
                    8：访问权限不能严于父类。

                重载和重写区别：
                    重载：发送在一个类。
                    重写：发生在两个或以上的类：

               比较 ==和equals的区别：
                  equals：只能用于比较引用数据类型，用来比较地址，但是如果String类的话
                    用来比较值。
                  ==：
                    如果用来比较引用数据类型，比较的是地址。
                    如果用来比较基本数据类型，比较的是值。


      三：多态：是一个行为的不同的转态。----->是特殊应用场景下的技术
             原则：重写是多态的基础（前提）。

             应用场景：
                1：父类当形参,传递子类的实例。
                2：父类但返回值类型--父类接收子类实例。
            向上转型：父类接收子类。
            向下转型：父类转转子类。
            *
             instanceof :用来判断一个实例是否是某个类立体实例。

      四：抽象类和抽象方法：解决代码冗余
                抽象方法：使用了重写，使用了多态思想前提下使用。
                如何使用：使用 abstract来修饰。
                抽象类：有抽象方法的类必须是抽象类。
                特征：
                     1：抽象方法必须出现在抽象类中。
                     2：抽象方法必须在子类中被重写，除非子类也是一个抽象类。
                     3：抽象方法没有方法体。
                     4：抽象类中可以有非抽象方法。
                     5：抽象类不被实例化。
                抽象类和普通类区别：
                    1：抽象类不能被实例化，普通类可以吧。
                    2：抽象类有抽象方法，普通类没有。
                    3：抽象类中的抽象方法，必须别子类重写，普通类方法不需要。

       五：接口：纯粹版本的抽象类，或者说是抽象类的特殊的应用场景的实现。
             解决什么问题：
                  弥补继承单根性的劣势。
             接口中成员都有哪些特点：
                成员变量：默认都是public static final的，必须显式初始化
                方法：默认都是public abstract的，接口没有构造方法。
            抽象类vs接口：
                相同点：
                     代表系统的抽象层。
                    都不能被实例化。
                    都能包含抽象方法。
                不同点：
                    在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法。
                    抽象类便于复用，接口便于代码维护。
                    一个类只能继承一个直接的父类，但可以实现多个接口。
     *
     *
     *
     * */
    /**异常：
     *  为什么要学：
     1：没有办法专注业务.
     2：代码质量不行，冗余太高。
     3：没有自己掌握程序的容错能力。
     什么是异常:
     异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
     异常处理:
     Java编程语言使用异常处理机制为程序提供了错误处理的能力
     Java中如何进行异常处理 ：使用了5个关键字，try、catch、 finally、throw、throws
     异常分类:ThrowAble
     Erro:仅靠程序本身无法，恢复的严重错误硬件异常。
     Exception:由Java应用程序  抛出和处理的非严重错误
     运行时异常：运行时异常，不要求程序必须做出处理
     检查异常：必须要处理的异常。
     ***/
}
